﻿//using System;
//using ParserGenerator.Collections;
//using ParserGenerator.Exceptions;
//using ParserGenerator.Expressions;
//using ParserGenerator.TypeDeclarations;
//using ParserGenerator.TypeExpressions;

//namespace ParserGenerator.Statements
//{
//    [Serializable]
//    public class StatementValidator : IStatementValidator
//    {
//        public ExpressionValidator ExpressionValidator { get; set; }
//        public GrammarDeclarationValidator GrammarDeclarationValidator { get; set; }
//        public TypeDeclarationValidator TypeDeclarationValidator { get; set; }
//        public TypeExpressionValidator TypeExpressionValidator { get; set; }

//        public virtual void ValidateWithItem(WithItem n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ExpressionValidator.ValidateExpression(n.ContextExpression);
//            if (n.OptionalVariables != null)
//                ExpressionValidator.ValidateExpression(n.OptionalVariables, ExpressionUsage.Store);
//        }

//        public virtual void ValidateWithItemList(Sequence<WithItem> list)
//        {
//            if (list == null)
//                throw new ArgumentNullException(nameof(list));
//            foreach (WithItem item in list)
//                ValidateWithItem(item);
//        }

//        public virtual void ValidateExceptionHandler(ExceptionHandler n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            if (n.Type != null)
//                TypeExpressionValidator.ValidateTypeExpression(n.Type);
//            ValidateBody(n.Body, "exception handler");
//        }

//        public virtual void ValidateExceptionHandlerList(Sequence<ExceptionHandler> list)
//        {
//            if (list == null)
//                throw new ArgumentNullException(nameof(list));
//            foreach (ExceptionHandler item in list)
//                ValidateExceptionHandler(item);
//        }

//        private void AssertNotEmpty<T>(Sequence<T> list, string what, string owner)
//        {
//            if (list == null)
//                throw new ArgumentNullException(nameof(list));
//            if (what == null)
//                throw new ArgumentNullException(nameof(what));
//            if (owner == null)
//                throw new ArgumentNullException(nameof(owner));
//            if (list.Count == 0)
//            {
//                string message = string.Format(SR.EmptySequenceIn, what, owner);
//                throw new ValueErrorException(message);
//            }
//        }

//        private void ValidateBody(Sequence<Statement> body, string owner)
//        {
//            if (body == null)
//                throw new ArgumentNullException(nameof(body));
//            if (owner == null)
//                throw new ArgumentNullException(nameof(owner));
//            AssertNotEmpty(body, nameof(body), owner);
//            ValidateSatementList(body);
//        }

//        private void ValidateTargets(Sequence<Expression> targets, ExpressionUsage usage)
//        {
//            if (targets == null)
//                throw new ArgumentNullException(nameof(targets));
//            AssertNotEmpty(targets, nameof(targets), usage == ExpressionUsage.Delete ? "Delete" : "Assign");
//            ExpressionValidator.ValidateExpressionList(targets, usage);
//        }

//        public virtual void ValidateDecoratorList(Sequence<Expression> list)
//        {
//            if (list == null)
//                throw new ArgumentNullException(nameof(list));
//            ExpressionValidator.ValidateExpressionList(list);
//        }

//        public virtual void ValidateFunctionDeclaration(FunctionDeclaration n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ValidateBody(n.Body, "function statement");
//            ExpressionValidator.ValidateParameterList(n.Parameters);
//            ValidateDecoratorList(n.Decorators);
//            if (n.Returns != null)
//                TypeExpressionValidator.ValidateTypeExpression(n.Returns);
//        }

//        public virtual void ValidateClassDeclaration(ClassDeclaration n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ValidateBody(n.Body, "class statement");
//            ExpressionValidator.ValidatePositionalArgumentList(n.Bases);
//            ExpressionValidator.ValidateKeywordArgumentList(n.Keywords);
//            ValidateDecoratorList(n.Decorators);
//        }

//        public virtual void ValidateGrammarDeclaration(GrammarDeclaration n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ExpressionValidator.ValidatePositionalArgumentList(n.Bases);
//            ExpressionValidator.ValidateKeywordArgumentList(n.Keywords);
//            ValidateDecoratorList(n.Decorators);
//            GrammarDeclarationValidator.ValidateGrammarDeclaration(n);
//        }

//        public virtual void ValidateTypeDeclaration(TypeDeclaration n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            TypeDeclarationValidator.ValidateTypeDeclaration(n);
//        }

//        public virtual void ValidateStatement(Statement n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            n.AcceptStatementValidator(this);
//        }

//        public virtual void ValidateSatementList(Sequence<Statement> list)
//        {
//            if (list == null)
//                throw new ArgumentNullException(nameof(list));
//            foreach (Statement item in list)
//                ValidateStatement(item);
//        }

//        public virtual void ValidatePassStatement(Statement.Pass n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//        }

//        public virtual void ValidateBreakStatement(Statement.Break n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//        }

//        public virtual void ValidateContinueStatement(Statement.Continue n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//        }

//        public virtual void ValidateReturnStatement(Statement.Return n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            if (n.Value != null)
//                ExpressionValidator.ValidateExpression(n.Value);
//        }

//        public virtual void ValidateRaiseStatement(Statement.Raise n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            if (n.Exception != null)
//            {
//                ExpressionValidator.ValidateExpression(n.Exception);
//                if (n.Cause != null)
//                    ExpressionValidator.ValidateExpression(n.Cause);
//            }
//            else if (n.Cause != null)
//            {
//                SyntaxErrorException e = new SyntaxErrorException(SR.RaiseWithCauseButNoException);
//                e.AddLocation(n.Context);
//                throw e;
//            }
//        }

//        public virtual void ValidateAssertStatement(Statement.Assert n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ExpressionValidator.ValidateExpression(n.Test);
//            if (n.Message != null)
//                ExpressionValidator.ValidateExpression(n.Message);
//        }

//        public virtual void ValidateDeleteStatement(Statement.Delete n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ValidateTargets(n.Targets, ExpressionUsage.Delete);
//        }

//        public virtual void ValidateGlobalStatement(Statement.Global n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            AssertNotEmpty(n.Names, "names", "global statement");
//        }

//        public virtual void ValidateNonlocalStatement(Statement.Nonlocal n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            AssertNotEmpty(n.Names, "names", "nonlocal statement");
//        }

//        public virtual void ValidateImportStatement(Statement.Import n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            AssertNotEmpty(n.Bindings, "bindings", "import statement");
//        }

//        public virtual void ValidateFromImportStatement(Statement.FromImport n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            if (n.Level < -1)
//            {
//                SyntaxErrorException e = new SyntaxErrorException(SR.FromImportLevelInvalid);
//                e.AddLocation(n.Context);
//                throw e;
//            }
//            AssertNotEmpty(n.Bindings, "bindings", "import from statement");
//        }

//        public virtual void ValidateExprStatement(Statement.Expr n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ExpressionValidator.ValidateExpression(n.Value);
//        }

//        public virtual void ValidateAssignStatement(Statement.Assign n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ValidateTargets(n.Targets, ExpressionUsage.Store);
//            ExpressionValidator.ValidateExpression(n.Value);
//        }

//        public virtual void ValidateAugAssignStatement(Statement.AugAssign n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ExpressionValidator.ValidateExpression(n.Target, ExpressionUsage.Store);
//            ExpressionValidator.ValidateExpression(n.Value);
//        }

//        public virtual void ValidateAnnAssignStatement(Statement.AnnAssign n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            if (!n.Target.IsNameReference && n.IsSimple)
//            {
//                SyntaxErrorException e = new SyntaxErrorException(SR.AnnAssignWithSimpleNonNameTarget);
//                e.AddLocation(n.Context);
//                throw e;
//            }
//            ExpressionValidator.ValidateExpression(n.Target, ExpressionUsage.Store);
//            if (n.Value != null)
//                ExpressionValidator.ValidateExpression(n.Value);
//            TypeExpressionValidator.ValidateTypeExpression(n.Type);
//        }

//        public virtual void ValidateIncrementStatement(Statement.Increment n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ExpressionValidator.ValidateExpression(n.Target, ExpressionUsage.Store);
//        }

//        public virtual void ValidateDecrementStatement(Statement.Decrement n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ExpressionValidator.ValidateExpression(n.Target, ExpressionUsage.Store);
//        }

//        public virtual void ValidateBindStatement(Statement.Bind n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            if (n.Type != null)
//                TypeExpressionValidator.ValidateTypeExpression(n.Type);
//            ExpressionValidator.ValidateExpression(n.Value);
//        }

//        public virtual void ValidateIfStatement(Statement.If n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ExpressionValidator.ValidateExpression(n.Test);
//            ValidateBody(n.Body, "if statement");
//            ValidateSatementList(n.OrElse);
//        }

//        public virtual void ValidateWhileStatement(Statement.While n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ExpressionValidator.ValidateExpression(n.Test);
//            ValidateBody(n.Body, "while statement");
//            ValidateSatementList(n.OrElse);
//        }

//        public virtual void ValidateForStatement(Statement.For n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ExpressionValidator.ValidateExpression(n.Target, ExpressionUsage.Store);
//            ExpressionValidator.ValidateExpression(n.Iterator);
//            ValidateBody(n.Body, "for statement");
//            ValidateSatementList(n.OrElse);
//        }

//        public virtual void ValidateWithStatement(Statement.With n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            AssertNotEmpty(n.Items, "items", "with statement");
//            ValidateWithItemList(n.Items);
//            ValidateBody(n.Body, "with statement");
//        }

//        public virtual void ValidateTryStatement(Statement.Try n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ValidateBody(n.Body, "try statement");
//            if (n.Handlers.Count == 0 && n.FinalBody.Count == 0)
//            {
//                SyntaxErrorException e = new SyntaxErrorException(SR.TryHasNeitherHandlersNorFinally);
//                e.AddLocation(n.Context);
//                throw e;
//            }
//            if (n.Handlers.Count == 0 && n.OrElse.Count > 0)
//            {
//                SyntaxErrorException e = new SyntaxErrorException(SR.TryHasOrElseButNoHandlers);
//                e.AddLocation(n.Context);
//                throw e;
//            }
//            ValidateExceptionHandlerList(n.Handlers);
//            ValidateSatementList(n.FinalBody);
//            ValidateSatementList(n.OrElse);
//        }

//        public virtual void ValidateFunctionStatement(Statement.Function n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ValidateFunctionDeclaration(n.Declaration);
//        }

//        public virtual void ValidateClassStatement(Statement.Class n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ValidateClassDeclaration(n.Declaration);
//        }

//        public virtual void ValidateGrammarStatement(Statement.Grammar n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ValidateGrammarDeclaration(n.Declaration);
//        }

//        public virtual void ValidateDataTypeStatement(Statement.DataType n)
//        {
//            if (n == null)
//                throw new ArgumentNullException(nameof(n));
//            ValidateTypeDeclaration(n.Declaration);
//        }
//    }
//}
